package com.chushouya.product.service.admin.impl;

import com.chushouya.product.dto.admin.evaluateitem.*;
import com.general.framework.core.enums.StatusEnum;
import com.general.framework.core.exception.Ex;
import com.general.framework.core.lang.Beans;
import com.general.framework.core.lang.Check;
import com.general.framework.core.lang.Dates;
import com.general.framework.core.schema.PageResult;
import com.chushouya.product.dao.entity.CategoryEntity;
import com.chushouya.product.dao.entity.EvaluateItemEntity;
import com.chushouya.product.dao.entity.EvaluateItemValueEntity;
import com.chushouya.product.dao.repository.CategoryRepository;
import com.chushouya.product.dao.repository.EvaluateItemRepository;
import com.chushouya.product.dao.repository.EvaluateItemValueRepository;
//=====product.dto.admin.evaluateitem.*;
import com.chushouya.product.dto.admin.evaluateitem.*;
import com.chushouya.product.service.admin.EvaluateItemService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.Objects;

@Service
@Slf4j
public class EvaluateItemServiceImpl implements EvaluateItemService {

    @Resource
    private EvaluateItemRepository evaluateItemRepository;

    @Resource
    private EvaluateItemValueRepository evaluateItemValueRepository;

    @Resource
    private CategoryRepository categoryRepository;

    private CategoryEntity getCategory(Long categoryId) {
        Check.notNull(categoryId, "categoryId 不能为空");
        CategoryEntity category = categoryRepository.selectByPrimaryKey(categoryId);
        Check.notNull(category, "分类不存在");
        return category;
    }
    @Override
    public PageResult<EvaluateItemListDTO> selectEvaluateItemPageResult(EvaluateItemQuery query) {
        PageResult<EvaluateItemEntity> pageResult = evaluateItemRepository.selectPageResult(query);
        return PageResult.of(pageResult, EvaluateItemListDTO.class);
    }

    @Override
    public List<EvaluateItemListDTO> selectEvaluateItemList(EvaluateItemQuery query) {
        List<EvaluateItemEntity> list = evaluateItemRepository.selectList(query);
        return Beans.copyList(list, EvaluateItemListDTO.class);
    }

    @Override
    public EvaluateItemDetailDTO getEvaluateItemDetail(Long evaluateItemId) {
        Check.notNull(evaluateItemId, "evaluateItemId 不能为空");
        EvaluateItemEntity entity = evaluateItemRepository.selectByPrimaryKey(evaluateItemId);
        return Beans.copy(entity, EvaluateItemDetailDTO.class);
    }

    @Override
    public Long addEvaluateItem(EvaluateItemSaveDTO evaluateItem) {
        Check.notEmpty(evaluateItem.getItemName(), "估价项目名称不能为空");
        Check.notNull(evaluateItem.getCategoryId(), "分类ID不能为空");
        CategoryEntity category = getCategory(evaluateItem.getCategoryId());
        
        EvaluateItemEntity entity = Beans.copy(evaluateItem, EvaluateItemEntity.class);
        entity.setStatus(StatusEnum.normal.value());
        entity.setCreateTime(Dates.getTimeNow());
        entity.setCategoryName(category.getCategoryName());
        evaluateItemRepository.insertSelective(entity);
        return entity.getEvaluateItemId();
    }

    @Override
    public Long editEvaluateItem(EvaluateItemUpdateDTO evaluateItem) {
        Check.notNull(evaluateItem.getEvaluateItemId(), "evaluateItemId 不能为空");
        Check.notEmpty(evaluateItem.getItemName(), "估价项目名称不能为空");
        CategoryEntity category = getCategory(evaluateItem.getCategoryId());
        
        EvaluateItemEntity existEntity = evaluateItemRepository.selectByPrimaryKey(evaluateItem.getEvaluateItemId());
        Check.notNull(existEntity, "估价项目不存在");
        
        EvaluateItemEntity updateEntity = Beans.copy(evaluateItem, EvaluateItemEntity.class);
        updateEntity.setCategoryName(category.getCategoryName());
        evaluateItemRepository.updateByPrimaryKeySelective(updateEntity);
        return updateEntity.getEvaluateItemId();
    }

    @Override
    public void removeEvaluateItem(Long evaluateItemId) {
        Check.notNull(evaluateItemId, "evaluateItemId 不能为空");
        EvaluateItemEntity entity = evaluateItemRepository.selectByPrimaryKey(evaluateItemId);
        Check.notNull(entity, "估价项目不存在");
        EvaluateItemValueQuery query = new EvaluateItemValueQuery();
        query.setEvaluateItemId(entity.getEvaluateItemId());
        EvaluateItemValueEntity evaluateItemValue = evaluateItemValueRepository.selectOne(query);
        if (Objects.nonNull(evaluateItemValue)) {
            throw Ex.business("该属性下存在属性值，不能删除");
        }
        evaluateItemRepository.deleteByPrimaryKey(evaluateItemId);
    }

    @Override
    public Long editEvaluateItemStatus(Long evaluateItemId, Integer status) {
        Check.notNull(evaluateItemId, "evaluateItemId 不能为空");
        EvaluateItemEntity updateEntity = new EvaluateItemEntity();
        updateEntity.setEvaluateItemId(evaluateItemId);
        updateEntity.setStatus(status);
        evaluateItemRepository.updateByPrimaryKeySelective(updateEntity);
        return evaluateItemId;
    }

    @Override
    public List<EvaluateItemListDTO> selectEvaluateItemListByCategoryId(Long categoryId) {
        List<EvaluateItemEntity> list = evaluateItemRepository.selectListByCategoryId(categoryId);
        return Beans.copyList(list, EvaluateItemListDTO.class);
    }
}
